Examples - OPC Unified Architecture - Read a range of elements from an array

.NET

// This example shows how to read a range of values from an array.

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._UAIndexRangeList
{
    partial class Usage
    {
        public static void ReadValue()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object
            var client = new EasyUAClient();

            // Obtain the value, indicating that just the elements 2 to 4 should be returned
            object value;
            try
            {
                value = client.ReadValue(
                    new UAReadArguments(
                        endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;ns=2;i=10305",   // /Data.Static.Array.Int32Value
                        UAIndexRangeList.OneDimension(2, 4)));
            }
            catch (UAException uaException)
            {
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
                return;
            }

            // Cast to typed array
            var arrayValue = (Int32[]) value;

            // Display results
            for (int i = 0; i < 3; i++)
                Console.WriteLine("arrayValue[{0}]: {1}", i, arrayValue[i]);


            // Example output:
            //arrayValue[0]: 180410224
            //arrayValue[1]: 1919239969
            //arrayValue[2]: 1700185172
        }
    }
}

# This example shows how to read a range of values from an array.

# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object.
client = EasyUAClient()

# Obtain the value, indicating that just the elements 2 to 4 should be returned
try:
    arrayValue = IEasyUAClientExtension.ReadValue(client,
                                                  endpointDescriptor,
                                                  UANodeDescriptor('nsu=http://test.org/UA/Data/ ;ns=2;i=10305'),    # /Data.Static.Array.Int32Value
                                                  UAIndexRangeList.OneDimension(2, 4))
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()

# Display results.
for i, elementValue in enumerate(arrayValue):
    print('arrayValue[', i, ']: ', elementValue, sep='')

print()
print('Finished.')

' This example shows how to read a range of values from an array.

Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _UAIndexRangeList
    Friend Class Usage
        Public Shared Sub ReadValue()

            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Obtain the value, indicating that just the elements 2 to 4 should be returned
            Dim value As Object
            Try
                value = client.ReadValue( _
                    New UAReadArguments( _
                        endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10305", _
                        UAIndexRangeList.OneDimension(2, 4)))
                ' or "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try

            ' Cast to typed array
            Dim arrayValue = DirectCast(value, Int32())

            ' Display results
            For i = 0 To 2
                Console.WriteLine("arrayValue[{0}]: {1}", i, arrayValue(i))
            Next
        End Sub
    End Class
End Namespace

COM

// This example shows how to read a range of values from an array.

class procedure Usage.ReadValue;
var
  Client: _EasyUAClient;
  EndpointDescriptor: string;
  ReadArguments1: _UAReadArguments;
  Arguments, Results: OleVariant;
  I: Cardinal;
  IndexRange: _UAIndexRange;
  IndexRangeList: OpcLabs_EasyOpcUA_TLB._UAIndexRangeList;
  ArrayValue: OleVariant;
  Value: Integer;
  ValueResult: _ValueResult;
begin
  EndpointDescriptor := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';

  // Instantiate the client object
  Client := CoEasyUAClient.Create;

  // Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
  IndexRangeList := CoUAIndexRangeList.Create;
  IndexRange := CoUAIndexRange.Create;
  IndexRange.Minimum := 2;
  IndexRange.Maximum := 4;
  IndexRangeList.Add(IndexRange);

  ReadArguments1 := CoUAReadArguments.Create;
  ReadArguments1.EndpointDescriptor.UrlString := EndpointDescriptor;
  ReadArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;ns=2;i=10305';
  ReadArguments1.IndexRangeList := IndexRangeList;

  Arguments := VarArrayCreate([0, 0], varVariant);
  Arguments[0] := ReadArguments1;

  // Obtain value.
  TVarData(Results).VType := varArray or varVariant;
  TVarData(Results).VArray := PVarArray(Client.ReadMultipleValues(Arguments));

  ValueResult := IInterface(Results[0]) as _ValueResult;
  if not ValueResult.Succeeded then
    begin
      WriteLn(' *** Failure: ', ValueResult.Exception.GetBaseException.Message);
      Exit;
    end;

  // Display results
  ArrayValue := ValueResult.Value;
  for I := VarArrayLowBound(ArrayValue, 1) to VarArrayHighBound(ArrayValue, 1) do
  begin
      Value := ArrayValue[I];
      WriteLn('arrayValue[', I, ']: ', Value);
  end;

  VarClear(Results);
  VarClear(Arguments);

  // Example output:
  //arrayValue[0]: 180410224
  //arrayValue[1]: 1919239969
  //arrayValue[2]: 1700185172
end;

// This example shows how to read a range of values from an array.

$EndpointDescriptor = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";

// Instantiate the client object
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");

// Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
$IndexRangeList = new COM("OpcLabs.EasyOpc.UA.UAIndexRangeList");
$IndexRange = new COM("OpcLabs.EasyOpc.UA.UAIndexRange");
$IndexRange->Minimum = 2;
$IndexRange->Maximum = 4;
$IndexRangeList->Add($IndexRange);

$ReadArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAReadArguments");
$ReadArguments1->EndpointDescriptor->UrlString = $EndpointDescriptor;
$ReadArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305";
$ReadArguments1->IndexRangeList = $IndexRangeList;

$arguments[0] = $ReadArguments1;

// Obtain value.
$results = $Client->ReadMultipleValues($arguments);

$ValueResult = $results[0];

if (!$ValueResult->Succeeded) {
    printf("*** Failure: %s\n", $ValueResult->ErrorMessageBrief);
    Exit();
}

// Display results
$ArrayValue = $ValueResult->Value;
for ($i = 0; $i <= 2; $i++)
{
    printf("arrayValue[d]s\n", $i, $ArrayValue[$i]);
}

// Example output:
//arrayValue[0]: 180410224
//arrayValue[1]: 1919239969
//arrayValue[2]: 1700185172

Rem This example shows how to read a range of values from an array.

Private Sub Usage_ReadValue_Command_Click()
    OutputText = ""
    
    Dim endpointDescriptor As String
    'endpointDescriptor = "http://opcua.demo-this.com:51211/UA/SampleServer"
    'endpointDescriptor = "https://opcua.demo-this.com:51212/UA/SampleServer/"
    endpointDescriptor = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"

    ' Instantiate the client object
    Dim Client As New EasyUAClient

    ' Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
    Dim indexRangeList As New UAIndexRangeList
    Dim indexRange As New UAIndexRange
    indexRange.Minimum = 2
    indexRange.Maximum = 4
    indexRangeList.Add indexRange
    
    Dim readArguments1 As New UAReadArguments
    readArguments1.endpointDescriptor.UrlString = endpointDescriptor
    readArguments1.NodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305"
    Set readArguments1.indexRangeList = indexRangeList

    Dim arguments(0) As Variant
    Set arguments(0) = readArguments1

    ' Obtain value.
    Dim results() As Variant
    results = Client.ReadMultipleValues(arguments)

    Dim valueResult As valueResult
    Set valueResult = results(0)
    If Not valueResult.Succeeded Then
        OutputText = OutputText & "*** Failure: " & valueResult.Exception.GetBaseException.Message & vbCrLf
        Exit Sub
    End If
    
    ' Display results
    Dim arrayValue() As Long
    arrayValue = valueResult.value
    
    Dim i: For i = LBound(arrayValue) To UBound(arrayValue)
        OutputText = OutputText & "arrayValue(" & i & "):" & arrayValue(i) & vbCrLf
    Next

    ' Example output:
    'arrayValue(0): 180410224
    'arrayValue(1): 1919239969
    'arrayValue(2): 1700185172
End Sub

Rem This example shows how to read a range of values from an array.

Option Explicit

Dim endpointDescriptor: endpointDescriptor = _
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    '"http://opcua.demo-this.com:51211/UA/SampleServer"  
    '"https://opcua.demo-this.com:51212/UA/SampleServer/"

' Instantiate the client object
Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.UA.EasyUAClient")

' Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
Dim IndexRangeList: Set IndexRangeList = CreateObject("OpcLabs.EasyOpc.UA.UAIndexRangeList")
Dim IndexRange: Set IndexRange = CreateObject("OpcLabs.EasyOpc.UA.UAIndexRange")
IndexRange.Minimum = 2
IndexRange.Maximum = 4
IndexRangeList.Add IndexRange
'
Dim ReadArguments1: Set ReadArguments1 = CreateObject("OpcLabs.EasyOpc.UA.OperationModel.UAReadArguments")
ReadArguments1.EndpointDescriptor.UrlString = endpointDescriptor
ReadArguments1.NodeDescriptor.NodeId.ExpandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305"
ReadArguments1.IndexRangeList = IndexRangeList

Dim arguments(0)
Set arguments(0) = ReadArguments1

' Obtain the value.
Dim results: results = Client.ReadMultipleValues(arguments)
Dim ValueResult: Set ValueResult = results(0)
If Not ValueResult.Succeeded Then
    WScript.Echo "*** Failure: " & ValueResult.Exception.GetBaseException().Message
    WScript.Quit
End If
' VBScript can only handle well arrays of VARIANTs; most other COM tool will be able to use simply the .Value property.
Dim arrayValue: arrayValue = ValueResult.RegularizedValue

' Display results
Dim i: For i = 0 To 2
    WScript.Echo "arrayValue[" & i & "]: " & arrayValue(i)
Next


' Example output:
'arrayValue[0]: 180410224
'arrayValue[1]: 1919239969
'arrayValue[2]: 1700185172

Conceptual

OPC UA Index Range Lists